This fixes an unfortunate (but highly specific) divergence in the points-to analysis.
The following piece of code is a (more or less) minimal example that exhibits the divergence:

class foo():
    pass

while True:
    foo = foo[foo]

The culprit is the support for subscripted types originally introduced in #1728. Essentially, given the above, foo (the variable) can point to the subscripted type foo[foo], but then also the subscripted type (foo[foo])[(foo[foo]) and so on. Thankfully, only two projects on LGTM.com exhibited the above divergence.

To fix this, we block the recursion by requiring that the two types involved in a type subscripting operation (A and B in A[B]) must not themselves be subscripted types.

As this fixes an (obscure) regression in the analysis, I don't think it needs a change note.

Performance comparison here: https://git.semmle.com/gist/taus/8c8f31f2bb72055e50cc97bcce070747

Looks like a ~30% increase in performance across the board. Also seems to remove a bunch of false positives.